home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / GapText.C < prev    next >
C/C++ Source or Header  |  1992-08-26  |  9KB  |  407 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "GapText.h" 
  6.  
  7. #include "Class.h"
  8. #include "RegularExp.h"
  9. #include "Error.h"
  10. #include "Math.h"
  11.  
  12. const int cShrinkFactor = 2,
  13.       cMaxOutput    = 500,
  14.       cInitialSize  = 16;
  15.  
  16. //---- GapText -----------------------------------------------------------------
  17.  
  18. NewMetaImpl(GapText,Text, (T(size), T(length), T(part1len), T(gaplen),
  19.             TV(body, part1len), TV(body2, part2len)));
  20.  
  21. //---- private -----------------------------------------------------------------
  22.  
  23. void GapText::Update(int l)
  24. {
  25.     part1len= l;
  26.     gaplen= size - length;
  27.     part2body= body + gaplen;
  28.     part2len= length - part1len;
  29.     body2= part2body + part1len;
  30. }
  31.  
  32. void GapText::MoveGap(int to)
  33. {
  34.     if (to == part1len)
  35.     return;
  36.     if (part1len > to)
  37.     MemCpy(body+to+gaplen, body+to, part1len-to);
  38.     else 
  39.     MemCpy(body+part1len, body+part1len+gaplen, to-part1len);
  40.  
  41.     part1len= to; 
  42. }            
  43.  
  44. void GapText::CopyTo(byte *dst, int from, int to)
  45. { 
  46.     // Copy Text between 'from' and 'to' to 'dst'
  47.     int beforegap= Math::Max(0, part1len-from) - Math::Max(0, part1len-to);
  48.     int aftergap= Math::Max(0, to - part1len) - Math::Max(0, from-part1len);
  49.  
  50.     if (beforegap) 
  51.     MemCpy(dst, body+from, beforegap);
  52.     if (aftergap)
  53.     MemCpy(dst+beforegap, part2body+Math::Max(part1len, from), aftergap);
  54. }
  55.  
  56. void GapText::Expand(int to, int moveto)
  57. { 
  58.     // Expand size of Text to 'to'
  59.     byte *pos, *part2;
  60.  
  61.     if (to < size) 
  62.     return;
  63.  
  64.     if (moveto > length)
  65.     moveto= length;
  66.  
  67.     size= to;
  68.     pos= new byte[size];
  69.     part2= pos+size-length;
  70.  
  71.     if (moveto < part1len) {
  72.     MemCpy(pos, body, moveto);
  73.     MemCpy(part2+moveto, body+moveto, part1len-moveto);
  74.     MemCpy(part2+part1len, body2, length-part1len);
  75.     } else {
  76.     MemCpy(pos, body, part1len);
  77.     MemCpy(pos+part1len, body2, moveto-part1len);
  78.     MemCpy(part2+moveto, part2body+moveto, length-moveto);
  79.     }
  80.     delete body;
  81.     body= pos;
  82.     Update(moveto);
  83. }
  84.  
  85. void GapText::Shrink(int to)
  86. { 
  87.     byte *pos;
  88.  
  89.     if ((to == 0) || (to < length))
  90.     to= size/cShrinkFactor + 1;
  91.  
  92.     if ( (to > size) || (to < length) ) 
  93.     return;
  94.  
  95.     size= to;
  96.     pos= new byte[size];
  97.     MemCpy(pos, body, part1len);
  98.     MemCpy(pos+part1len, body+part1len+gaplen, part2len);
  99.     delete body;
  100.     body= pos;
  101.     Update(length);
  102. }
  103.  
  104. GapText::GapText(int s, Font *fd)
  105. { 
  106.     size= Math::Max(cInitialSize, s);
  107.     body= new byte[size];
  108.     Init(0, fd);
  109. }
  110.  
  111. GapText::GapText(byte *buf, int len, Font *fd)
  112. {   
  113.     if (len < 0)
  114.     len= strlen((char*)buf);
  115.     size= Math::Max(cInitialSize, len);
  116.     body= new byte[size];
  117.     MemCpy(body, buf, len);
  118.     Init(len, fd);
  119. }
  120.  
  121. void GapText::InitNew()
  122. {
  123.     Text::InitNew();
  124.     Init(0, gSysFont);
  125. }
  126.  
  127. void GapText::Init(int l, Font *fd)
  128. {
  129.     length= l;
  130.     Update(l);
  131.     charStyle= new_CharStyle(fd);
  132.     SetDefTab(fd->Width(' ')*8);
  133.     if (!IsTerminated()) 
  134.     Terminate();
  135. }
  136.  
  137. GapText::~GapText()
  138. {
  139.     SafeDelete(body);
  140.     part2body= 0;
  141. }
  142.  
  143. void GapText::Terminate()
  144. {
  145.     if (IsTerminated())
  146.     return;
  147.     AddChar(Size(), '\0');
  148. }
  149.     
  150. void GapText::AddChar(int at, byte b)
  151. {
  152.     if (HighWaterMark(1))
  153.     Expand(GrowSize(size+1), Size());
  154.     else     
  155.     MoveGap(at);
  156.     body[at]= b;
  157.     length+= 1;
  158.     Update(part1len+1);
  159. }
  160.  
  161. void GapText::ReplaceRange(int from, int to, Text *tsrc, int sfrom, int sto)
  162. {
  163.     GapText *src;
  164.     byte *buf= 0;
  165.  
  166.     if (!CheckRange(End(), from, to))
  167.     Error("ReplaceRange", "out of range");
  168.  
  169.     if (!tsrc->IsKindOf(GapText)) {  // convert the text into a GapText
  170.     int s= sto-sfrom;
  171.     buf= new byte[s+1];
  172.     tsrc->CopyInStr(buf, s+1, sfrom, sto);
  173.     src= new GapText(buf, s);
  174.     sto= sto-sfrom;
  175.     sfrom= 0;
  176.     } else
  177.     src= (GapText *)tsrc;
  178.     
  179.     int shift= (sto - sfrom) - (to - from);
  180.     if (HighWaterMark(shift))
  181.     Expand(GrowSize(size+shift), from);
  182.     else
  183.     MoveGap(from);
  184.  
  185.     src->CopyTo(body+from, sfrom, sto);
  186.  
  187.     length+= shift;
  188.     Update(part1len + (sto-sfrom));
  189.  
  190.     if (LowWaterMark())
  191.     Shrink();   
  192.     if (buf) {
  193.     delete src;
  194.     delete buf;
  195.     }
  196. }
  197.  
  198. void GapText::CopyInStr(byte *str, int strsize, int from, int to)
  199. {
  200.     if (!CheckRange(length, from, to))
  201.     Error("CopyInStr", "out of range");
  202.     to= Math::Min(to, from + strsize-1);   
  203.     CopyTo(str, from, to);
  204.     str[to-from]= '\0';
  205. }
  206.  
  207. Text *GapText::MakeScratchText(byte *buf, int len) 
  208. {
  209.     if (buf)
  210.     return new GapText(buf, len);
  211.     return new GapText(len);
  212. }
  213.  
  214. int GapText::Search(RegularExp *rex, int *nMatched, int start, int range, 
  215.                          bool dir)
  216. {
  217.     int pos;
  218.  
  219.     if (dir == cSearchForward) 
  220.     pos= rex->SearchForward2((char*)body, part1len,
  221.                         (char*)(body+part1len+gaplen), 
  222.             length-part1len, start, range, 0, nMatched);
  223.     else {
  224.     // BUG in RegularExp::SearchBackward2 ??
  225.     MoveGap(length);
  226.     pos= rex->SearchBackward((char*)body, nMatched, start, length, range, 0);
  227.     } 
  228.     return pos;
  229. }
  230.  
  231. byte *GapText::GetLineAccess(byte **buf, int from, int to)
  232. {    
  233.     if (!CheckRange(length, from, to))
  234.     return 0;
  235.  
  236.     if ((part1len < to) && (part1len >= from)) {
  237.     // Gap is in between 
  238.     *buf= (byte*) Realloc(*buf, to-from + 20);
  239.     for (int i= from; i < to; i++)
  240.         (*buf)[i-from]= CharAt(i);
  241.     return *buf;
  242.     }
  243.     if (part1len < from) 
  244.     return &part2body[from];
  245.     return &body[from];
  246. }
  247.  
  248. byte& GapText::operator[](int i)
  249. {
  250.     //----> should notify about possible changes but how?? 
  251.     i= Math::Min(i, length-1);
  252.     if (i < part1len)
  253.     return body[i];
  254.     return part2body[i];
  255. }
  256.  
  257. int GapText::Size()
  258. { 
  259.     return length; 
  260. }                                         
  261.  
  262. TextIter *GapText::MakeIterator(int from, int to)
  263. {
  264.     return new GapTextIter(this, from, to);
  265. }
  266.  
  267. OStream& GapText::PrintOn(OStream& s)
  268. {
  269.     Text::PrintOn(s);
  270.     MoveGap(length);
  271.     return s.PrintString(body, Size());
  272. }
  273.  
  274. IStream& GapText::ReadFrom(IStream& s)
  275. {
  276.     Text::ReadFrom(s);
  277.     SafeDelete(body);
  278.     s.ReadString(&body, &length);
  279.     size= length;
  280.     Update(length);
  281.     return s;
  282. }
  283.  
  284. OStream& GapText::PrintOnAsPureText(OStream& s)
  285. {
  286.     s.write(body, part1len);
  287.     s.write(body2, End() - part1len);
  288.     return s;
  289. }
  290.  
  291. IStream& GapText::ReadFromAsPureText(IStream &s, long sizeHint)
  292. {
  293.     char ch;
  294.  
  295.     if (sizeHint > 0 && ((int)(sizeHint - size)) > 0)
  296.     Expand((int)sizeHint + 50);
  297.     if (body == 0)
  298.     body= new byte[size= 1024];
  299.     length= 0;
  300.     
  301.     while (s.get(ch)) {
  302.     if (length >= size){
  303.         part2body= body ;
  304.         body= new byte[size= (size+1)*2];
  305.         MemCpy(body, part2body, length);
  306.         delete part2body;
  307.     }
  308.     body[length++]= ch;
  309.     }
  310.  
  311.     Update(length);
  312.     Terminate();
  313.     if (!s.eof())
  314.     Error("ReadFromAsPureText", "missing EOF");
  315.     return s;
  316. }
  317.  
  318. //---- GapTextIter -------------------------------------------------------------
  319.  
  320. GapTextIter::GapTextIter(Text *s, int from, int to) : TextIter(s, from, to)
  321. {
  322.     if (!s->IsKindOf(GapText))
  323.     Error("GapTextIter::Error", "GapText expected (%s received)", s->ClassName());
  324.     st= (GapText*)s;
  325.     
  326.     escape= st->GetMarkChar();
  327.     nextFontChange= st->GetNextFontChange(ce, sp);
  328.     if (sp == 0) 
  329.     Error("GapTextIter::GapTextIter", "style is nil");
  330. }
  331.  
  332. void GapTextIter::Reset(Text *s, int from, int to)
  333. { 
  334.     if (!s->IsKindOf(GapText))
  335.     Error("GapTextIter::Reset", "GapTextIter expected (%s received)",
  336.                                 s->ClassName());
  337.     st= (GapText*)s;
  338.  
  339.     TextIter::Reset(s, from, to);
  340.     nextFontChange= st->GetNextFontChange(ce, sp);
  341.     escape= st->GetMarkChar();
  342.     if (sp == 0) 
  343.     Error("GapTextIter::Reset", "style is nil");
  344. }
  345.  
  346. int GapTextIter::GraphicSize(int at, LineDesc *l)
  347. {
  348.     VisualMark *vmp= st->GetVisualMarkAt(at);
  349.     if (l)
  350.     l->Max(vmp->Base(), vmp->GetExtent().y);
  351.     return vmp->GetExtent().x;
  352. }
  353.  
  354. int GapTextIter::operator()(int *w, LineDesc *ld)  
  355. {
  356.     unget= ce;
  357.     if (ce == upto )
  358.     return cEOT;
  359.  
  360.     TestFontChange(sp);
  361.     int ch= CharAt(ce);
  362.     if (TestVisualMark(ce, ch)) {
  363.     if (w)
  364.         *w= GraphicSize(ce, ld);
  365.     }
  366.     else {
  367.     if (w)      
  368.         *w= sp->GetFont()->Width(ch);
  369.     if (ld)
  370.         ld->FromFont(sp->GetFont());
  371.     }
  372.     ce++;
  373.     return ch;
  374. }
  375.  
  376. int GapTextIter::Token(int *w, LineDesc *ld)  
  377. {
  378.     unget= ce;
  379.     *w= 0;
  380.     TestFontChange(sp);
  381.     if (ld) 
  382.     ld->FromFont(sp->GetFont());
  383.     if (ce >= upto)
  384.     return cEOT;
  385.     register int ch= CharAt(ce);
  386.     
  387.     if (TestVisualMark(ce ,ch)) {
  388.     *w= GraphicSize(ce, ld);
  389.     ce++;
  390.     return ch;
  391.     }
  392.     
  393.     if (Iswordwrap(ch)) {
  394.     *w= sp->GetFont()->Width(ch);
  395.     ce++;
  396.     return ch;
  397.     }
  398.     while (ce < upto && !Iswordwrap(CharAt(ce)) && !TestVisualMark(ce, CharAt(ce))) {
  399.     if (TestFontChange(sp) && ld)
  400.         ld->Max(sp->GetFont());
  401.     ch= CharAt(ce++);
  402.     *w+= sp->GetFont()->Width(ch);
  403.     }
  404.     return ch;
  405. }
  406.  
  407.